import GCJ_CLASS_TYPE=require('./../../common/GCJ_CLASS_TYPE');
import ObjBase=require('./ObjBase');
import DEFINE=require('./../../common/DEFINE');
import PageInfo=require('./../../common/PageInfo');
import ObjPosition=require('./../base/ObjPosition');
import GroupObj=require('./GroupObj');
import TableRowObj=require('./TableRowObj');
import TableCellObj=require('./TableCellObj');
import TextObj=require('./TextObj');
import TextExtObj=require('./TextExtObj');
import FColor=require('./../color/FColor');
import GlobalData=require('./../../z/GlobalData');
var fs=require('fs');
var path=require('path');
var CommonUtil=require('../../../../common/util/CommonUtil');
var CONFIG=require('../../../../common/config');

export  = TableExtObj;
    

/**
 *
 * @author 
 *
 */
class TableExtObj extends GroupObj {
    // ***********************************************
    // GroupObj.children 记录表格行数组 Array<TableRow>
    // 各行高度相同, 列宽度按比例设置 
    // ***********************************************
    
    public static BORDER_STYLE_ALL: number=1;// 普通样式：显示所有边框线
    public static BORDER_STYLE_LINE_H_NO_TOP: number=2;// 固定样式：只有每行下边框线（没有左/右/上边框线）
    public static BORDER_STYLE_LINE_H: number=3;// 固定样式：只有横线
    public static BORDER_STYLE_LINE_V: number=4;// 固定样式：只有竖线
    public static BORDER_STYLE_FRAME_H: number=5;// 固定样式：只有每行下边框线 + Table最外框线
    public static BORDER_STYLE_FRAME_V: number=6;// 固定样式：只有每列左边框线 + Table最外框线
    public static BORDER_STYLE_FRAME: number=7;// 固定样式：只有最外框线
    public static BORDER_STYLE_NONE: number=8;// 固定样式：无边框线
    
    // 边框样式
    public borderStyle: number=TableExtObj.BORDER_STYLE_ALL;
    
    public rowCnt: number=0;// 行数
    public colCnt: number=0;// 列数
    public rtoColW: number[]=[];// 列宽比例系数,例如: 三列[3,3,4]
    
    public constructor(g?) {
        super(g);  //引入全局数据
        this.ct=GCJ_CLASS_TYPE.CLASS_TYPE_TableExtObj;
    }
    
    // 生成微调数据会用到
    public toJsonOfMinTextExt(): string {
        // 去掉父json字符串的头尾
        var superJson=super.toJsonOfMinTextExt();
        superJson=superJson.substr(1,superJson.length-2);

        var ret="{";
        ret+=superJson;

        ret+=',';
        ret+=('\"borderStyle\":'+this.borderStyle);

        ret+=',';
        ret+='\"rowCnt\":'+this.rowCnt;
        ret+=',';
        ret+='\"colCnt\":'+this.colCnt;
        
        var arr='[';
        if(this.rtoColW.length>0) {
            for(var i=0;i<this.rtoColW.length;i++) {
                arr+=this.rtoColW[i];
                arr+=','
            }
            arr=arr.substr(0,arr.length-1);// 去除多余的逗号
        }
        arr+=']';
        ret+=(',\"rtoColW\":'+arr);

        ret+="}";
        return ret;
    }
    
    // 转成json字符串
    public toJson(): string {
        var superJson=super.toJson();
        superJson=superJson.substr(1,superJson.length-2);

        var ret='{';
        ret+=superJson;
        
        ret+=',';
        ret+='"borderStyle":'+this.borderStyle;

        ret+=',';
        ret+='"rowCnt":'+this.rowCnt;
        
        ret+=',';
        ret+='"colCnt":'+this.colCnt;
        
        var arr='[';
        if(this.rtoColW.length>0) {
            for(var i=0;i<this.rtoColW.length;i++) {
                arr+=this.rtoColW[i];
                arr+=','
            }
            arr=arr.substr(0,arr.length-1);// 去除多余的逗号
        }
        arr+=']';
        ret+=(',"rtoColW":'+arr);

        ret+='}';
        return ret;
    }

    // 从json对象(注意不是json字符串)中解析
    // 参数：self,true表示只拷贝自身数据，而不拷贝子的数据
    public fromJson(jsonObj,versionId,self?) {
        super.fromJson(jsonObj,versionId,self);
        
        if(jsonObj.hasOwnProperty("borderStyle")) {
            this.borderStyle=jsonObj.borderStyle;
        }

        if(jsonObj.hasOwnProperty("rowCnt")) {
            this.rowCnt=jsonObj.rowCnt;
        }
        
        if(jsonObj.hasOwnProperty("colCnt")) {
            this.colCnt=jsonObj.colCnt;
        }
        
        this.rtoColW.splice(0,this.rtoColW.length);
        if(jsonObj.hasOwnProperty("rtoColW")) {
            this.rtoColW=jsonObj.rtoColW;
        }
    }
	
    // 获取对象名称
    public getObjetName(): string {
        return "表格";
    }
    
    // 当作普通对象处理(整体)
    public isSimple(): boolean {
        return false;
    }
    
    // 刷新表格数据
    public refresh() {
        super.refresh();
        
        this.refreshByRowColCnt();
    }
    
    // 根据this.rowCnt/this.colCnt刷新表格
    public refreshByRowColCnt() {
        if(this.rowCnt>0 && this.colCnt>0) {
            
            if(this.rowCnt>this.children.length) {
                // 需要加行
                this.addRow(this.rowCnt-this.children.length);
            } else if(this.rowCnt<this.children.length) {
                // 需要减行
                this.delRow(this.children.length-this.rowCnt);
            }
            
            // 循环行
            for(var i=0;i<this.children.length;i++) {
                var row: TableRowObj=<TableRowObj>this.children[i];
                
                if(this.colCnt>row.children.length) {
                    // 需要加列
                    row.addCell(this.colCnt-row.children.length);
                } else if(this.colCnt<row.children.length) {
                    // 需要减列
                    row.delCell(row.children.length-this.colCnt);
                }
            }
            
            // 刷新行列编号
            this.refreshRowColIndex();

            // 刷新行高
            this.setRowHeight(this.pos.h/this.rowCnt,true);
            // 刷新列宽
            this.setColWidthRto(this.rtoColW);
            
            // 刷新边框样式
            this.setBorderStyle();
            
        } else {
            console.log('Row/Col Cnt Err!');
        }
    }
    
    /**
     * 设置Table行高(各行高度相同)
     * bStrict: true严格设置
     */ 
    public setRowHeight(rowH: number, bStrict:boolean=false) {
        if(rowH&&rowH>0) {
            if(!bStrict) {
                // 通过最外层拉伸设置
                var newH=rowH*this.rowCnt;
                super.expand(2/*SJGSelectRect.CONTROL_BOTTOM*/,1,newH/this.pos.h,true);
                
            } else {
                // 严格设置
                var tableH=0;
                for(var i=0;i<this.children.length;i++) {
                    var row: TableRowObj=<TableRowObj>this.children[i];
                    row.pos.h=rowH;
                    row.pos.y=rowH*i;
                    
                    for(var j=0;j<row.children.length;j++) {
                        var cell: TableCellObj=<TableCellObj>row.children[j];
                        cell.pos.y=0;
                        cell.expand(2/*SJGSelectRect.CONTROL_BOTTOM*/,1,rowH/cell.pos.h,true);
                    }
                    
                    tableH+=rowH;
                }
                
                this.pos.h=tableH;
            }
        }
    }
    
    // 刷新行列编号
    public refreshRowColIndex(){
        for(var i=0;i<this.children.length;i++) {
            var row: TableRowObj=<TableRowObj>this.children[i];
            row.rowNum=i;
            
            for(var j=0;j<row.children.length;j++) {
                var cell: TableCellObj=<TableCellObj>row.children[j];
                cell.colNum=j;
            }
        }
    }
    
    /**
     * 设置列宽比例
     * 不改变table总宽度，只缩放各个单元格宽度
     */
    public setColWidthRto(rto: number[] = null) {        
        if(rto && rto.length>=this.colCnt) {
            var t=0;// 总步长
            for(var n=0;n<this.colCnt;n++){
                var c=Number(rto[n]||'0')||0;
                if(c<=0) {
                    console.log("setRowWidthRto Param Err!");
                    return;
                }
                t+=c;
            }
            
            // 转为百分率,方便计算
            var rtoBase=[];
            for(var n=0;n<this.colCnt;n++) {
                rtoBase.push(TableExtObj.roundFloat(Number(rto[n]||'0')/t, 4));
            }
            
            // 循环行
            for(var i=0;i<this.rowCnt;i++) {
                var row: TableRowObj=<TableRowObj>this.children[i];
                
                // 循环单元格
                var offsetX=0;
                for(var j=0;j<this.colCnt;j++) {
                    var cell: TableCellObj=<TableCellObj>row.children[j];
                    
                    // 单元格x坐标更新
                    cell.pos.x=(j>0)? offsetX:0;
                    // 单元格的宽度缩放比
                    var newW=this.pos.w*rtoBase[j];
                    cell.expand(1/*SJGSelectRect.CONTROL_RIGHT*/,newW/cell.pos.w,1,true);
                    // 记录x偏移
                    offsetX+=newW;
                }
            }
            
            // 更新rto记录
            this.rtoColW=rto.slice(0,this.colCnt);
            
        } else {
            console.log("setRowWidthRto Param Err!");
        }
    }
    
    /**
     * 设置Table边框颜色
     */ 
    public setBorderColor(color: FColor) {
        if(color) {
            // 循环行
            for(var i=0;i<this.rowCnt;i++) {
                var row: TableRowObj=<TableRowObj>this.children[i];
                
                // 循环单元格
                for(var j=0;j<this.colCnt;j++) {
                    var cell: TableCellObj=<TableCellObj>row.children[j];
                    cell.border.top.color=color.copy();
                    cell.border.bottom.color=color.copy();
                    cell.border.left.color=color.copy();
                    cell.border.right.color=color.copy();
                }
            }
        }
    }
    
    /**
     * 设置Table边框宽度
     */ 
    public setBorderWitdh(w: number=null) {
        if(w!=null && w>=0) {
            // 循环行
            for(var i=0;i<this.rowCnt;i++) {
                var row: TableRowObj=<TableRowObj>this.children[i];
                
                // 循环单元格
                for(var j=0;j<this.colCnt;j++) {
                    var cell: TableCellObj=<TableCellObj>row.children[j];
                    cell.border.top.w=w;
                    cell.border.bottom.w=w;
                    cell.border.left.w=w;
                    cell.border.right.w=w;
                }
            }
        }
    }
    
    /**
     * 设置Table边框样式
     */ 
    public setBorderStyle(style:number=null) {
        if(style && style>0) {
            this.borderStyle=style;
        }
        
        // 循环行
        for(var i=0;i<this.rowCnt;i++) {
            var row: TableRowObj=<TableRowObj>this.children[i];
            
            // 循环单元格
            for(var j=0;j<this.colCnt;j++) {
                var cell: TableCellObj=<TableCellObj>row.children[j];

                if(this.borderStyle==TableExtObj.BORDER_STYLE_LINE_H_NO_TOP) {
                    // 只有下横线
                    cell.border.top.v=0;
                    cell.border.left.v=0;
                    cell.border.right.v=0;
                    cell.border.bottom.v=1;
                    
                } else if(this.borderStyle==TableExtObj.BORDER_STYLE_LINE_H) {
                    // 只有横线
                    cell.border.top.v=(i==0)? 1:0;;
                    cell.border.left.v=0;
                    cell.border.right.v=0;
                    cell.border.bottom.v=1;

                } else if(this.borderStyle==TableExtObj.BORDER_STYLE_LINE_V) {
                    // 只有竖线
                    cell.border.top.v=0;
                    cell.border.left.v=1;
                    cell.border.right.v=(j==this.colCnt-1)? 1:0;
                    cell.border.bottom.v=0;

                } else if(this.borderStyle==TableExtObj.BORDER_STYLE_FRAME_H)  {
                    // 横线+外框
                    cell.border.top.v = (i==0)? 1:0;
                    cell.border.left.v = (j==0)? 1:0;
                    cell.border.right.v = (j==this.colCnt-1)? 1:0;
                    cell.border.bottom.v = 1
                    
                } else if(this.borderStyle==TableExtObj.BORDER_STYLE_FRAME_V) {
                    // 竖线+外框
                    cell.border.top.v = (i==0)? 1:0;
                    cell.border.left.v = 1;
                    cell.border.right.v = (j==this.colCnt-1)? 1:0;
                    cell.border.bottom.v = (i==this.rowCnt-1)? 1:0;

                } else if(this.borderStyle==TableExtObj.BORDER_STYLE_FRAME) {
                    // 外框
                    cell.border.top.v = (i==0)? 1:0;
                    cell.border.left.v = (j==0)? 1:0;
                    cell.border.right.v = (j==this.colCnt-1)? 1:0;
                    cell.border.bottom.v = (i==this.rowCnt-1)? 1:0;

                } else if(this.borderStyle==TableExtObj.BORDER_STYLE_NONE) {
                    // 无框
                    cell.border.top.v=0;
                    cell.border.left.v=0;
                    cell.border.right.v=0;
                    cell.border.bottom.v=0;

                } else {
                    // 默认
                    cell.border.top.v=1;
                    cell.border.left.v=1;
                    cell.border.right.v=1;
                    cell.border.bottom.v=1;
                }
            }
        }
    }
    
    /**
     * 改变表格行列数
     * newRowCnt: 行数
     * newColCnt: 列数
     */
    public chgRowColSize(newRowCnt:number=null, newColCnt:number=null) {
        // 改变行数
        if(newRowCnt>0 && newRowCnt!=this.rowCnt) {
            // 减行
            if(newRowCnt<this.rowCnt) {
                this.delRow(this.rowCnt-newRowCnt);
            }

            // 增行
            if(newRowCnt>this.rowCnt) {
                this.addRow(newRowCnt-this.rowCnt);
            }
        }
        
        // 改变列数
        if(newColCnt>0 && newColCnt !=this.colCnt) {
            // 减列
            if(newColCnt<this.colCnt) {
                this.delCol(this.colCnt-newColCnt);
            }
            
            // 加列
            if(newColCnt>this.colCnt) {
                this.addCol(newColCnt-this.colCnt);
            }
        }
    }
    
    /**
     * 添加表格行
     * num: 添加行数
     */ 
    public addRow(num: number) {
        if(num>0) {
            // 备份当前表格最后一行,用于复制
            var jsonStr=(<TableRowObj>this.children[this.children.length-1]).toJson().replace(/\n/g,'\\n');

            for(var i=0;i<num;i++) {
                // 复制行
                var copyRow: TableRowObj=new TableRowObj(this.getGlobalData());
                var ver=0;
                copyRow.fromJson(JSON.parse(jsonStr),ver,false);// 需拷贝子
                copyRow.rowNum+=(i+1);// 修改行号
                if(copyRow.rowType==TableRowObj.ROW_TYPE_TITLE) {
                    // TODO
                    copyRow.rowType=TableRowObj.ROW_TYPE_NORMAL;// 设为普通行
                    copyRow.setCellBgColor(null);// 清除行背景色
                }
                
                var idMaps=[];
                copyRow.deepResetId(idMaps);
                copyRow.pos.y+=(copyRow.pos.h*(i+1));// 修改新行位置
                // 添加到Table
                this.addChild(copyRow,this.children.length);
                    
                // 修改table高度
                this.pos.h+=copyRow.pos.h;
            }
            
            // 重设行数
            this.rowCnt=this.children.length;
            // 刷新边框
            this.setBorderStyle();
        }
    }
    /**
     * 删除表格行
     * num: 删除行数(最多删至1行)
     */
    public delRow(num: number) {
        if(num>0) {
            // 最多删至1行
            var newRowCnt=(num>=this.children.length)? 1:(this.children.length-num);
            
            for(var i=newRowCnt;i<this.children.length;i++) {
                var child: TableRowObj=<TableRowObj>this.children[i];
                child.parent=null; // 删除子对父的引用
                    
                // 修改table高度
                this.pos.h-=child.pos.h;
            }
            // 减去尾部多余行
            this.children.splice(newRowCnt,this.children.length-newRowCnt);
            
            // 重设行数
            this.rowCnt=this.children.length;
            // 刷新边框
            this.setBorderStyle();
        }
    }
    
    /**
     * 添加表格列
     * num: 添加列数
     */
    public addCol(num: number) {
        if(num>0) {
            for(var i=0;i<this.children.length;i++) {// 循环各行
                var row: TableRowObj=<TableRowObj>this.children[i];
                // 备份当前行的最后一列,用于复制
                var jsonStr=(<TableCellObj>row.children[row.children.length-1]).toJson().replace(/\n/g,'\\n');

                for(var j=0;j<num;j++) {
                    // 复制
                    var copyCell: TableCellObj=new TableCellObj(this.getGlobalData());
                    var ver=this.getGlobalData().templateEidtor().getKernel().m_template.head.ver;
                    copyCell.fromJson(JSON.parse(jsonStr),ver,false);// 需拷贝子
                    copyCell.colNum+=(j+1);// 修改列号
                    var idMaps=[];
                    copyCell.deepResetId(idMaps);
                    copyCell.pos.x+=(copyCell.pos.w*(j+1));// 修改新列位置
                    // 添加到每行
                    row.addChild(copyCell,row.children.length);
                        
                    // 修改row宽度
                    row.pos.w+=copyCell.pos.w;
                    // 修改table宽度
                    if(i==0) {
                        this.pos.w+=copyCell.pos.w;
                    }
                }
            }
            
            // 重设列数
            this.colCnt+=num;
            // 刷新边框
            this.setBorderStyle();
        }
    }
    /**
     * 删除表格列
     * num: 删除列数(最多删至1列)
     */
    public delCol(num: number) {
        if(num>0) {
            // 最多删至1列
            var newColCnt=(num>=this.colCnt)? 1:(this.colCnt-num);
            
            for(var i=0;i<this.children.length;i++) {// 循环各行
                var row: TableRowObj=<TableRowObj>this.children[i];

                for(var j=newColCnt;j<this.colCnt;j++) {// 循环单元格
                    var cell: TableCellObj=<TableCellObj>row.children[j];
                    cell.parent=null; // 删除子对父的引用
                    
                    // 修改row宽度
                    row.pos.w-=cell.pos.w;
                    // 修改table宽度
                    if(i==0) {
                        this.pos.w-=cell.pos.w;
                    }
                }
                row.children.splice(newColCnt,row.children.length-newColCnt);// 减去尾部多余列
            }
            
            // 重设列数
            this.colCnt=newColCnt;
            // 刷新边框
            this.setBorderStyle();
        }
    }
    
    /**
     * 设置默认表格数据
     * obj: 表格对象
     * rowCnt: 表格行数
     * colCnt: 表格列数
     * return: false参数错误/true设置成功
     */ 
    public static createDefTableContent(obj:TableExtObj, rowCnt:number, colCnt:number):boolean {
        if(!(obj instanceof TableExtObj) || rowCnt<=0 || colCnt<=0) {
            return false;
        }
        
        obj.rowCnt=rowCnt;
        obj.colCnt=colCnt;
        obj.rtoColW=[];
        for(var n=0;n<colCnt;n++) {
            obj.rtoColW.push(1);// 默认各列宽度一样
        }

        var cellH=obj.pos.h/obj.rowCnt;
        var cellW=obj.pos.w/obj.colCnt;
        
        obj.removeAllChild();
        
        // 添加行
        for(var i=0;i<obj.rowCnt;i++) {
            var row: TableRowObj=new TableRowObj(obj.getGlobalData());
            obj.getGlobalData().objManager().saveObject(row);
            obj.addChild(row,obj.children.length);// 加入Table
        
            // 设置行数据
            row.rowNum=i;// 行编号
            if(i==0) {
                row.rowType=TableRowObj.ROW_TYPE_TITLE;// 首行
            }
            row.pos.x=0;
            row.pos.y=cellH*i;
            row.pos.w=obj.pos.w;
            row.pos.h=cellH;
            
            // 添加单元格
            for(var j=0;j<obj.colCnt;j++) {
                var cell: TableCellObj=new TableCellObj(obj.getGlobalData());
                obj.getGlobalData().objManager().saveObject(cell);
                row.addChild(cell,row.children.length);// 加入TableRow
                
                // 设置单元格数据
                cell.colNum=j;// 列编号
                cell.pos.x=cellW*j;
                cell.pos.y=0;
                cell.pos.w=cellW;
                cell.pos.h=cellH;

                // 边框默认颜色
                cell.border.top.color=FColor.orangeColor();
                cell.border.bottom.color=FColor.orangeColor();
                cell.border.left.color=FColor.orangeColor();
                cell.border.right.color=FColor.orangeColor();

                if(row.rowType==TableRowObj.ROW_TYPE_TITLE) {
                    // 首行背景色
                    cell.bgcolor=FColor.from(192,192,192);
                }
                
                // 默认单元格内容
                var txt: TextExtObj=new TextExtObj(obj.getGlobalData());
                obj.getGlobalData().objManager().saveObject(txt);
                cell.addChild(txt,cell.children.length);
                txt.pos.x=0;
                txt.pos.y=0;
                txt.pos.w=cellW;
                txt.pos.h=cellH;
                txt.color=FColor.blackColor();
                txt.te="默认文字";
                txt.style.fs=18;
                txt.style.po=TextObj.POSITION_CENTER;
                txt.style.vpo=TextObj.V_POSITION_CENTER;
            }
        }
        
        // 刷新边框样式
        obj.setBorderStyle();
        return true;
    }

    public static roundFloat(val,n) {
        var t=Math.pow(10,parseInt(n));
        return Math.round(parseFloat(val)*t)/t;
    }

}
//SJG_MARK_END-------------------------
